// const AppError = require('./AppError');
import { ObjectLiteral, Repository } from 'typeorm';

/**
 * 保留对象的指定属性
 * @param {*} obj
 * @param  {...any} props
 * @returns
 */
export const pick = function (obj, ...props) {
  if (!obj || typeof obj !== 'object') {
    return obj;
  }
  const newObj = {};
  for (const key in obj) {
    if (props.includes(key)) {
      newObj[key] = obj[key];
    }
  }
  return newObj;
};

// /**
//  * @param {*} vis  validate.js 校验函数
//  * @param {*} data  校验数据
//  * @returns 是否验证失败
//  */
// exports.visHandler = function (vis, data) {
//   let res = vis(data);
//   if (res) {
//     // 验证失败统一处理
//     console.log('验证失败', res);
//     return res;
//   } else {
//     console.log('通过验证');
//   }
// };

/**
 * 请求返回数据
 * @param {*} data
 * @param {*} msg 提示消息
 * @returns
 */
export function sendResult(data, msg = '一切ok') {
  return {
    code: '00000',
    msg,
    data,
  };
}

// /**
//  * 捕获异常通用封装，返回结果需要再次处理
//  * @param {*} promise
//  * @returns
//  *
//  */
// exports.to = function (promise) {
//   return promise
//     .then((data) => [null, data]) // 成功时返回 [null, 数据]
//     .catch((error) => [error, undefined]); // 失败时返回 [错误, undefined]
// };

// /**
//  * 捕获异常通用封装，返回结果不需要处理
//  * @param {*} promise
//  * @returns
//  *
//  * 使用：await toi(adminServ.findByPage(searchObj),res,next);
//  */
// exports.toi = function (promise, res, next) {
//   return promise
//     .then((data) => res.send(sendResult(data))) // 将数据格式化后返回客户端
//     .catch((error) => next(new AppError(error))); // 进入异常中间件进行处理
// };

/**
 * 获取目标数据的祖先id列表
 * @param {*} repository  // 模型
 * @param {*} parentId  // 目标id
 * @param {*} ancestors // 祖先id列表
 * @returns
 */
export async function findAncestors<T extends ObjectLiteral>(
  repository: Repository<T>,
  parentId,
  ancestors: any[] = [],
): Promise<string[]> {
  // 查找当前节点第一个父节点
  const node = await repository.findOne({ where: { id: parentId } });
  if (!node) {
    return ['0', ...ancestors.map((item: any) => item.id)]; // 如果节点不存在，返回当前祖先列表
  }
  // 将当前节点添加到祖先列表
  ancestors.unshift(node);
  // 如果当前节点有父节点，递归查找
  if (node.parentId) {
    return await findAncestors(repository, node.parentId, ancestors);
  }
  // 返回祖先列表
  return ['0', ...ancestors.map((item: any) => item.id)];
}

/**
 * 构建树
 * @param {*} departments 存在父子关系的扁平列表
 * @param {*} parentId  每一项的父级ID
 * @returns
 */
export const buildTree = function (departments: any[] = [], parentId = 0) {
  const tree: any[] = [];
  // 遍历全部
  for (const department of departments) {
    // 找到顶级
    if (department.parentId == parentId) {
      // 构建后数据，添加到数组中
      const dept: any = { label: department.name, value: department.id };
      // 继续找这一项的自己
      const children = buildTree(departments, department.id);
      if (children.length) {
        // 这边递归得到的children就是 dept 格式了
        dept.children = children;
      }
      tree.push(dept);
    }
  }
  return tree;
};

/**
 * 构建树(不懂数据)
 * @param {*} departments 存在父子关系的扁平列表
 * @param {*} parentId  每一项的父级ID
 * @returns
 */
export const buildTreeOriginal = function (
  departments: any[] = [],
  parentId = 0,
) {
  const tree: any[] = [];
  // 遍历全部
  for (const department of departments) {
    // 找到顶级
    if (department.parentId == parentId) {
      // 构建后数据，添加到数组中
      const dept: any = { ...department };
      // 继续找这一项的自己
      const children = buildTreeOriginal(departments, department.id);
      if (children.length) {
        // 这边递归得到的children就是 dept 格式了
        dept.children = children;
      }
      tree.push(dept);
    }
  }
  return tree;
};

/**
 * 将菜单转换为路由数
 * @param {*} list
 */
export const buildRoute = function (list) {
  const map = new Map(); // 用于存储节点
  const roots: any[] = []; // 存储顶级节点

  // list = list.filter((item) => !(item.type == 4 || item.type == 'BUTTON'));

  // 将每个节点添加到 map 中
  list.forEach((item) => {
    // map.set(item.id, { ...item, children: [] });

    // 构建成路由结构
    map.set(item.id, {
      component: item.component,
      // 将item.routePath中正则匹配到的部分，替换成小括号部分，并转大写
      name:
        item.routeName ||
        (item.routePath &&
          item.routePath.replace(/-(\w)/g, (_, letter) =>
            letter.toUpperCase(),
          )) ||
        Date.now(),
      path: item.routePath,
      redirect: item.redirect,
      meta: {
        alwaysShow: Boolean(item.alwaysShow),
        hidden: item.visible == 0,
        icon: item.icon,
        params: item.params,
        title: item.name,
      },
      children: [],
    });
  });

  // 获取所有节点的 id,如果 parentId为0或不在列表中，则代表顶级节点
  const idSet = new Set(list.map((item) => item.id));
  const rootIds = list
    .filter((item) => item.parentId == '0' || !idSet.has(item.parentId))
    .map((item) => item.id);

  // 构建树形结构
  list.forEach((item) => {
    if (rootIds.includes(item.id)) {
      // 如果 parentId 为 null，则是顶级节点
      roots.push(map.get(item.id));
    } else {
      // 否则，将节点添加到其父节点的 children 数组中
      const parent = map.get(item.parentId);
      if (parent) {
        parent.children.push(map.get(item.id));
      }
    }
  });

  return roots;
};
